/**
 * 表单验证工具类
 * 提供常用的表单验证方法
 */

import { APP_CONFIG, REGEX, utils } from './config.js'

/**
 * 验证规则类
 */
class Validator {
	/**
	 * 验证手机号格式
	 * @param {String} phone 手机号
	 * @returns {Boolean} 是否有效
	 */
	static isValidPhone(phone) {
		if (!phone) return false
		return REGEX.PHONE.test(phone)
	}

	/**
	 * 验证邮箱格式
	 * @param {String} email 邮箱
	 * @returns {Boolean} 是否有效
	 */
	static isValidEmail(email) {
		if (!email) return false
		return REGEX.EMAIL.test(email)
	}

	/**
	 * 验证密码强度
	 * @param {String} password 密码
	 * @returns {Object} 验证结果
	 */
	static validatePassword(password) {
		const result = {
			isValid: false,
			errors: [],
			strength: 0
		}

		if (!password) {
			result.errors.push('密码不能为空')
			return result
		}

		// 长度检查
		if (password.length < APP_CONFIG.PASSWORD_MIN_LENGTH) {
			result.errors.push(`密码长度至少${APP_CONFIG.PASSWORD_MIN_LENGTH}位`)
			return result
		}
		
		if (password.length > APP_CONFIG.PASSWORD_MAX_LENGTH) {
			result.errors.push(`密码长度不能超过${APP_CONFIG.PASSWORD_MAX_LENGTH}位`)
			return result
		}
		
		// 基本长度符合要求，设置基础强度
		result.strength += 1
		
		// 以下检查仅用于计算密码强度，不影响验证结果
		
		// 包含小写字母
		if (/[a-z]/.test(password)) {
			result.strength += 1
		}

		// 包含大写字母
		if (/[A-Z]/.test(password)) {
			result.strength += 1
		}

		// 包含数字
		if (/\d/.test(password)) {
			result.strength += 1
		}

		// 包含特殊字符
		if (/[!@#$%^&*(),.?":{}|<>]/.test(password)) {
			result.strength += 1
		}

		// 密码有效性判断 - 只要长度符合要求即可
		result.isValid = true

		return result
	}

	/**
	 * 验证用户名格式
	 * @param {String} username 用户名
	 * @returns {Object} 验证结果
	 */
	static validateUsername(username) {
		const result = {
			isValid: false,
			errors: []
		}

		if (!username) {
			result.errors.push('用户名不能为空')
			return result
		}

		// 长度检查
		if (username.length < 3 || username.length > 20) {
			result.errors.push('用户名长度必须在3-20个字符之间')
		}

		// 字符检查
		if (!REGEX.USERNAME.test(username)) {
			result.errors.push('用户名只能包含字母、数字和下划线')
		}

		result.isValid = result.errors.length === 0
		return result
	}

	/**
	 * 验证验证码格式
	 * @param {String} code 验证码
	 * @param {Number} length 验证码长度，默认使用配置文件中的长度
	 * @returns {Boolean} 是否有效
	 */
	static isValidVerificationCode(code, length = APP_CONFIG.SMS_CODE_LENGTH) {
		if (!code) return false
		if (length === 6) {
			return REGEX.CODE.test(code)
		} else {
			const codeRegex = new RegExp(`^\\d{${length}}$`)
			return codeRegex.test(code)
		}
	}

	/**
	 * 验证必填字段
	 * @param {String} value 字段值
	 * @param {String} fieldName 字段名称
	 * @returns {Object} 验证结果
	 */
	static required(value, fieldName = '字段') {
		const result = {
			isValid: false,
			error: ''
		}

		if (!value || (typeof value === 'string' && value.trim() === '')) {
			result.error = `${fieldName}不能为空`
		} else {
			result.isValid = true
		}

		return result
	}

	/**
	 * 批量验证表单
	 * @param {Object} formData 表单数据
	 * @param {Array} rules 验证规则数组
	 * @returns {Object} 验证结果
	 */
	static validateForm(formData, rules) {
		const result = {
			isValid: true,
			errors: {},
			firstError: ''
		}

		for (const rule of rules) {
			const { field, label, validators } = rule
			const value = formData[field]

			for (const validator of validators) {
				let validationResult

				if (typeof validator === 'function') {
					validationResult = validator(value, label)
				} else if (typeof validator === 'object') {
					const { type, message, ...options } = validator
					validationResult = this.runValidator(type, value, label, options)
					if (!validationResult.isValid && message) {
						validationResult.error = message
					}
				}

				if (!validationResult.isValid) {
					result.isValid = false
					result.errors[field] = validationResult.error
					if (!result.firstError) {
						result.firstError = validationResult.error
					}
					break // 一个字段遇到错误就停止验证该字段
				}
			}
		}

		return result
	}

	/**
	 * 运行指定类型的验证器
	 * @param {String} type 验证器类型
	 * @param {*} value 值
	 * @param {String} label 字段标签
	 * @param {Object} options 选项
	 * @returns {Object} 验证结果
	 */
	static runValidator(type, value, label, options = {}) {
		switch (type) {
			case 'required':
				return this.required(value, label)
			case 'phone':
				return {
					isValid: this.isValidPhone(value),
					error: this.isValidPhone(value) ? '' : `请输入正确的${label}格式`
				}
			case 'email':
				return {
					isValid: this.isValidEmail(value),
					error: this.isValidEmail(value) ? '' : `请输入正确的${label}格式`
				}
			case 'password':
				const passwordResult = this.validatePassword(value)
				return {
					isValid: passwordResult.isValid,
					error: passwordResult.errors.join('，')
				}
			case 'username':
				const usernameResult = this.validateUsername(value)
				return {
					isValid: usernameResult.isValid,
					error: usernameResult.errors.join('，')
				}
			case 'code':
				return {
					isValid: this.isValidVerificationCode(value, options.length),
					error: this.isValidVerificationCode(value, options.length) ? '' : `请输入${options.length || 6}位验证码`
				}
			default:
				return { isValid: true, error: '' }
		}
	}
}

// 常用验证规则配置
const VALIDATION_RULES = {
	// 登录表单验证规则
	LOGIN: [
		{
			field: 'account',
			label: '账号',
			validators: [
				{ type: 'required' }
			]
		},
		{
			field: 'password',
			label: '密码',
			validators: [
				{ type: 'required' }
			]
		}
	],

	// 验证码登录验证规则
	LOGIN_CODE: [
		{
			field: 'phone',
			label: '手机号',
			validators: [
				{ type: 'required' },
				{ type: 'phone' }
			]
		},
		{
			field: 'verificationCode',
			label: '验证码',
			validators: [
				{ type: 'required' },
				{ type: 'code', length: 6 }
			]
		}
	],

	// 注册表单验证规则
	REGISTER: [
		{
			field: 'username',
			label: '用户名',
			validators: [
				{ type: 'required' },
				{ type: 'username' }
			]
		},
		{
			field: 'password',
			label: '密码',
			validators: [
				{ type: 'required' },
				{ type: 'password' }
			]
		},
		{
			field: 'email',
			label: '邮箱',
			validators: [
				{ type: 'required' },
				{ type: 'email' }
			]
		},
		{
			field: 'phone',
			label: '手机号',
			validators: [
				{ type: 'required' },
				{ type: 'phone' }
			]
		}
		// 已移除验证码验证
	]
}

export default Validator
export { VALIDATION_RULES }